// 引入必要的命名空间
using Microsoft.AspNetCore.Authorization; // 提供授权相关的功能
using Microsoft.AspNetCore.Mvc; // 提供MVC控制器和ActionResult支持
using System.Security.Claims; // 提供用户声明相关的功能
using UniversalAdmin.Application.DTOs; // 引入数据传输对象定义
using UniversalAdmin.Application.Services; // 引入服务层接口和实现
using UniversalAdmin.Shared.Enums; // 引入共享枚举定义

// 定义控制器的命名空间
namespace UniversalAdmin.Api.Controllers;

// 标记该类为API控制器
[ApiController]
// 定义路由模板，v1表示API版本，[controller]会自动替换为控制器名称
[Route("api/v1/[controller]")]
// 标记该控制器需要授权访问（开发环境下暂时禁用）
// [Authorize]
// 继承自ControllerBase，提供基础的控制器功能
public class ArticleController : ControllerBase
{
    // 注入文章服务接口
    private readonly IArticleService _articleService;

    // 构造函数，依赖注入IArticleService
    public ArticleController(IArticleService articleService)
    {
        _articleService = articleService;
    }

    // HTTP GET方法，获取文章列表，支持分页、状态、分类和关键字筛选
    [HttpGet]
    public async Task<IActionResult> GetArticles([FromQuery] int page = 1, [FromQuery] int pageSize = 10, [FromQuery] ArticleStatus? status = null, [FromQuery] Guid? categoryId = null, [FromQuery] string? keyword = null)
    {
        // 调用服务层获取文章列表
        var articles = await _articleService.GetArticlesAsync(page, pageSize, status, categoryId, keyword);
        // 返回200 OK响应，包含文章列表
        return Ok(articles);
    }

    // HTTP GET方法，根据ID获取单个文章
    [HttpGet("{id}")]
    public async Task<IActionResult> GetArticleById(Guid id)
    {
        // 调用服务层根据ID获取文章
        var article = await _articleService.GetArticleByIdAsync(id);
        // 如果文章不存在，返回404 Not Found响应
        if (article == null)
            return NotFound(new { message = "文章不存在" });
        // 返回200 OK响应，包含文章信息
        return Ok(article);
    }

    // HTTP POST方法，创建新文章
    [HttpPost]
    public async Task<IActionResult> CreateArticle([FromBody] CreateArticleDto dto)
    {
        try
        {
            // 获取当前用户ID
            var userId = GetCurrentUserId();
            // 调用服务层创建文章
            var article = await _articleService.CreateArticleAsync(dto, userId);
            // 返回201 Created响应，包含新文章的URI和文章信息
            return CreatedAtAction(nameof(GetArticleById), new { id = article.Id }, article);
        }
        catch (Exception ex)
        {
            // 如果发生异常，返回400 Bad Request响应，包含错误信息
            return BadRequest(new { message = ex.Message });
        }
    }

    // HTTP PUT方法，更新文章
    [HttpPut("{id}")]
    public async Task<IActionResult> UpdateArticle(Guid id, [FromBody] UpdateArticleDto dto)
    {
        try
        {
            // 调用服务层更新文章
            var article = await _articleService.UpdateArticleAsync(id, dto);
            // 如果文章不存在，返回404 Not Found响应
            if (article == null)
                return NotFound(new { message = "文章不存在" });
            // 返回200 OK响应，包含更新后的文章信息
            return Ok(article);
        }
        catch (Exception ex)
        {
            // 如果发生异常，返回400 Bad Request响应，包含错误信息
            return BadRequest(new { message = ex.Message });
        }
    }

    // HTTP DELETE方法，删除文章
    [HttpDelete("{id}")]
    public async Task<IActionResult> DeleteArticle(Guid id)
    {
        try
        {
            // 调用服务层删除文章
            var success = await _articleService.DeleteArticleAsync(id);
            // 如果文章不存在，返回404 Not Found响应
            if (!success)
                return NotFound(new { message = "文章不存在" });
            // 返回204 No Content响应，表示删除成功
            return NoContent();
        }
        catch (Exception ex)
        {
            // 如果发生异常，返回400 Bad Request响应，包含错误信息
            return BadRequest(new { message = ex.Message });
        }
    }

    // HTTP PUT方法，更新文章状态
    [HttpPut("{id}/status")]
    public async Task<IActionResult> UpdateArticleStatus(Guid id, [FromBody] ArticleStatus status)
    {
        try
        {
            // 调用服务层更新文章状态
            var success = await _articleService.UpdateArticleStatusAsync(id, status);
            // 如果文章不存在，返回404 Not Found响应
            if (!success)
                return NotFound(new { message = "文章不存在" });
            // 返回200 OK响应，包含成功消息
            return Ok(new { message = "状态更新成功" });
        }
        catch (Exception ex)
        {
            // 如果发生异常，返回400 Bad Request响应，包含错误信息
            return BadRequest(new { message = ex.Message });
        }
    }

    // HTTP POST方法，增加文章浏览次数
    [HttpPost("{id}/view")]
    public async Task<IActionResult> IncrementViewCount(Guid id)
    {
        // 调用服务层增加文章浏览次数
        var success = await _articleService.IncrementViewCountAsync(id);
        // 如果文章不存在，返回404 Not Found响应
        if (!success)
            return NotFound(new { message = "文章不存在" });
        // 返回200 OK响应，包含成功消息
        return Ok(new { message = "浏览次数已更新" });
    }

    // HTTP GET方法，根据分类ID获取文章列表，支持分页
    [HttpGet("category/{categoryId}")]
    public async Task<IActionResult> GetArticlesByCategory(Guid categoryId, [FromQuery] int page = 1, [FromQuery] int pageSize = 10)
    {
        // 调用服务层根据分类ID获取文章列表
        var articles = await _articleService.GetArticlesByCategoryAsync(categoryId, page, pageSize);
        // 返回200 OK响应，包含文章列表
        return Ok(articles);
    }

    // HTTP GET方法，根据作者ID获取文章列表，支持分页
    [HttpGet("author/{authorId}")]
    public async Task<IActionResult> GetArticlesByAuthor(Guid authorId, [FromQuery] int page = 1, [FromQuery] int pageSize = 10)
    {
        // 调用服务层根据作者ID获取文章列表
        var articles = await _articleService.GetArticlesByAuthorAsync(authorId, page, pageSize);
        // 返回200 OK响应，包含文章列表
        return Ok(articles);
    }

    // 私有方法，获取当前用户ID
    private Guid GetCurrentUserId()
    {
        // 从用户声明中获取用户ID
        var userIdClaim = User.FindFirst(ClaimTypes.NameIdentifier);
        // 如果用户ID不存在或无法解析为Guid，抛出异常
        if (userIdClaim == null || !Guid.TryParse(userIdClaim.Value, out var userId))
        {
            throw new UnauthorizedAccessException("无法获取当前用户ID");
        }
        // 返回用户ID
        return userId;
    }
}